/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package mx.edu.itesm.tps.proyecto.dao;

/**
 *
 * @author Emmanuel
 */
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.sql.DataSource;
import mx.edu.itesm.tps.proyecto.pojo.Tema;
import mx.edu.itesm.tps.proyecto.pojo.Subtema;
import mx.edu.itesm.tps.proyecto.pojo.Learning;
import mx.edu.itesm.tps.proyecto.pojo.Pregunta;
import mx.edu.itesm.tps.proyecto.pojo.Reactivo;
import mx.edu.itesm.tps.proyecto.pojo.Respuesta;
import mx.edu.itesm.tps.proyecto.pojo.Exam;
import mx.edu.itesm.tps.proyecto.pojo.ExamenReactivo;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.jdbc.core.simple.ParameterizedRowMapper;
import org.springframework.jdbc.core.simple.SimpleJdbcInsert;
import org.springframework.jdbc.core.simple.SimpleJdbcTemplate;
import org.springframework.webflow.action.FormAction;

public class GeneralDao extends FormAction implements ProjectEventDao {

    private SimpleJdbcTemplate simpleJdbcTemplate;
    private SimpleJdbcInsert insertTema;
    private SimpleJdbcInsert insertSubTema;
    private SimpleJdbcInsert insertLearning;
    private SimpleJdbcInsert insertReactivo;
    private SimpleJdbcInsert insertRespuesta;
    private SimpleJdbcInsert insertExamen;
    private SimpleJdbcInsert insertExamenReactivo;

    public void setDataSource(DataSource dataSource) {
        this.simpleJdbcTemplate = new SimpleJdbcTemplate(dataSource);
        this.insertTema = new SimpleJdbcInsert(dataSource).withTableName("tema");
        this.insertSubTema = new SimpleJdbcInsert(dataSource).withTableName("subtema");
        this.insertLearning = new SimpleJdbcInsert(dataSource).withTableName("learning");
        this.insertReactivo = new SimpleJdbcInsert(dataSource).withTableName("reactivo");
        this.insertRespuesta = new SimpleJdbcInsert(dataSource).withTableName("respuesta");
        this.insertExamen = new SimpleJdbcInsert(dataSource).withTableName("exams");
        this.insertExamenReactivo = new SimpleJdbcInsert(dataSource).withTableName("exam_reactivo");
    }

    public void addTema(String tema, String curso) {
        if (tema != null && !tema.equals("")) {
            Tema t = new Tema();
            t.setNombre(tema);
            t.setCurso(curso);

            add(t);
        }
    }

    public void addSubTema(String subtema, String tema) {
        if (subtema != null && !subtema.equals("")) {
            Subtema s = new Subtema();
            s.setNombre(subtema);
            s.setTema(tema);

            addS(s);
        }
    }

    public void addLearning(String lear, String subtema) {
        if (lear != null && !lear.equals("")) {
            Learning l = new Learning();
            l.setNombre(lear);
            l.setSubtema(subtema);

            addL(l);
        }
    }

    public void addReactivo(String reactivo, Integer tipo, String lear) {
        if (reactivo != null && !reactivo.equals("")) {
            Reactivo r = new Reactivo();
            r.setReactivo(reactivo);
            r.setTipo(tipo);
            r.setLearning(lear);

            addR(r);
        }
    }

    public void addRespuestaM(String resA, String resB, String resC, String correctoA, String correctoB, String correctoC, String resId) {
        System.out.println("Respuesta A" + resA);
        System.out.println("Respuesta B" + resB);
        System.out.println("Respuesta C" + resC);
        
        if (resA != null && !resA.equals("") && resB != null && resC != null) {
            Respuesta rA = new Respuesta();
            rA.setRespuesta(resA);
            rA.setCorrecto(correctoA);
            rA.setReactivo(resId);

            addResU(rA);

            Respuesta rB = new Respuesta();
            rB.setRespuesta(resB);
            rB.setCorrecto(correctoB);
            rB.setReactivo(resId);

            addResU(rB);

            Respuesta rC = new Respuesta();
            rC.setRespuesta(resC);
            rC.setCorrecto(correctoC);
            rC.setReactivo(resId);

            addResU(rC);
        }
    }

    public void addRespuestaV(String resV, String resF, String correctoV, String correctoF, String resId) {
        System.out.println("Respuesta V" + resV);
        System.out.println("Respuesta F" + resF);

        if (resV != null && !resV.equals("") && resF != null) {
            Respuesta rA = new Respuesta();
            rA.setRespuesta(resV);
            rA.setCorrecto(correctoV);
            rA.setReactivo(resId);

            addResU(rA);

            Respuesta rB = new Respuesta();
            rB.setRespuesta(resF);
            rB.setCorrecto(correctoF);
            rB.setReactivo(resId);

            addResU(rB);
        }
    }

    public void addRespuestaR(String res, String resId) {
        System.out.println("Respuesta Relacionar" + res);
        if (res != null && !res.equals("")) {
            String cor = "Si";
            Respuesta rA = new Respuesta();
            rA.setRespuesta(res);
            rA.setCorrecto(cor);
            rA.setReactivo(resId);

            addResU(rA);
        }
    }

    public void addRespuestaA(String res, String resId) {
        System.out.println("Respuesta Abierta" + res);
        if (res != null && !res.equals("")) {
            String cor = "Si";
            Respuesta rA = new Respuesta();
            rA.setRespuesta(res);
            rA.setCorrecto(cor);
            rA.setReactivo(resId);

            addResU(rA);
        }
    }

    public void addExamenR(String nC, String nE, String exa) {
        if (exa == null || nC == null || nE == null) {
            return;
        }

        Exam ex = new Exam();
        ex.setCourse(nC);
        ex.setName(nE);
        addExamen(ex);

        String[] examen = exa.split("\\|");

        int exaId = simpleJdbcTemplate.queryForInt("SELECT id FROM exams ORDER BY id DESC LIMIT 1 ", new Object[]{});

        for (int i = 0; i < examen.length; i++) {
            if (examen[i] != null) {
                ExamenReactivo eR = new ExamenReactivo();
                eR.setReactivoId(examen[i]);
                eR.setExamId(exaId + "");

                addExamenReac(eR);
            }
        }
    }

    public void add(Tema tema) {
        Map<String, Object> parameters = new HashMap<String, Object>(Tema.class.getDeclaredFields().length);
        parameters.put("nombre", tema.getNombre());
        parameters.put("curso", tema.getCurso());

        insertTema.execute(parameters);
    }

    public void addS(Subtema subtema) {
        Map<String, Object> parameters = new HashMap<String, Object>(Subtema.class.getDeclaredFields().length);
        parameters.put("nombre", subtema.getNombre());
        parameters.put("tema", subtema.getTema());

        insertSubTema.execute(parameters);
    }

    public void addL(Learning lear) {
        Map<String, Object> parameters = new HashMap<String, Object>(Learning.class.getDeclaredFields().length);
        parameters.put("nombre", lear.getNombre());
        parameters.put("subtema", lear.getSubtema());

        insertLearning.execute(parameters);
    }

    public void addR(Reactivo reac) {
        Map<String, Object> parameters = new HashMap<String, Object>(Reactivo.class.getDeclaredFields().length);
        parameters.put("reactivo", reac.getReactivo());
        parameters.put("tipo", reac.getTipo());
        parameters.put("learning", reac.getLearning());

        insertReactivo.execute(parameters);
    }

    public void addResU(Respuesta res) {
        Map<String, Object> parameters = new HashMap<String, Object>(Respuesta.class.getDeclaredFields().length);
        parameters.put("respuesta", res.getRespuesta());
        parameters.put("correcto", res.getCorrecto());
        parameters.put("reactivo", res.getReactivo());

        insertRespuesta.execute(parameters);
    }

    public void addExamen(Exam ex) {
        Map<String, Object> parameters = new HashMap<String, Object>(Exam.class.getDeclaredFields().length);
        parameters.put("name", ex.getName());
        parameters.put("course", ex.getCourse());

        insertExamen.execute(parameters);
    }

    public void addExamenReac(ExamenReactivo eR) {
        Map<String, Object> parameters = new HashMap<String, Object>(ExamenReactivo.class.getDeclaredFields().length);
        parameters.put("reactivo_id", eR.getReactivoId());
        parameters.put("exam_id", eR.getExamId());

        insertExamenReactivo.execute(parameters);
    }

    private class TemaMapper implements ParameterizedRowMapper<Tema> {

        public Tema mapRow(ResultSet rs, int rowNum) throws SQLException {
            Tema tema = new Tema();
            tema.setNombre(rs.getString("nombre"));
            tema.setCurso(rs.getString("curso"));
            return tema;
        }
    }

    private class SubtemaMapper implements ParameterizedRowMapper<Subtema> {

        public Subtema mapRow(ResultSet rs, int rowNum) throws SQLException {
            Subtema subtema = new Subtema();
            subtema.setNombre(rs.getString("nombre"));
            subtema.setTema(rs.getString("tema"));
            return subtema;
        }
    }

    private class LearningMapper implements ParameterizedRowMapper<Learning> {

        public Learning mapRow(ResultSet rs, int rowNum) throws SQLException {
            Learning lear = new Learning();
            lear.setNombre(rs.getString("nombre"));
            lear.setSubtema(rs.getString("subtema"));
            return lear;
        }
    }

    private class ReactivoMapper implements ParameterizedRowMapper<Reactivo> {

        public Reactivo mapRow(ResultSet rs, int rowNum) throws SQLException {
            Reactivo reac = new Reactivo();
            reac.setReactivo(rs.getString("reactivo"));
            reac.setTipo(rs.getInt("tipo"));
            reac.setLearning(rs.getString("learning"));
            return reac;
        }
    }

    private class RespuestaMapper implements ParameterizedRowMapper<Respuesta> {

        public Respuesta mapRow(ResultSet rs, int rowNum) throws SQLException {
            Respuesta res = new Respuesta();
            res.setRespuesta(rs.getString("respuesta"));
            res.setCorrecto(rs.getString("correcto"));
            res.setReactivo(rs.getString("reactivo"));
            return res;
        }
    }

    private class PreguntaMapper implements ParameterizedRowMapper<Pregunta> {

        public Pregunta mapRow(ResultSet rs, int rowNum) throws SQLException {
            Pregunta p = new Pregunta();

            return p;
        }
    }

    private class ExamenMapper implements ParameterizedRowMapper<Exam> {

        public Exam mapRow(ResultSet rs, int rowNum) throws SQLException {
            Exam eR = new Exam();
            eR.setName(rs.getString("name"));
            eR.setCourse(rs.getString("course"));

            return eR;
        }
    }

    private class ExamenRMapper implements ParameterizedRowMapper<ExamenReactivo> {

        public ExamenReactivo mapRow(ResultSet rs, int rowNum) throws SQLException {
            ExamenReactivo eR = new ExamenReactivo();
            eR.setReactivoId(rs.getString("reactivo_id"));

            return eR;
        }
    }
}
